home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / DTP / DTP_TEX / 3239.ZIP / DVIMTP.ZIP / DVIMTP.C < prev    next >
C/C++ Source or Header  |  1990-01-31  |  39KB  |  1,134 lines
  1. /* -*-C-*- dvimtp.c */
  2. /*-->dvimtp*/
  3. /**********************************************************************/
  4. /************************** dvijep ** or **dvimtp**********************/
  5. /**********************************************************************/
  6.  
  7. #include "dvihead.h"
  8.  
  9. /***********************************************************************
  10. ***********************************************************************/
  11.  
  12. /**********************************************************************/
  13. /************************  Device Definitions  ************************/
  14. /**********************************************************************/
  15.  
  16. /* All output-device-specific definitions go here.  This section must
  17. be changed when modifying a dvi driver for use on a new device */
  18.  
  19. #undef HPJETPLUS
  20. #define  HPJETPLUS   1            /* conditional compilation flag */
  21.  
  22. /* Comment out for Microsoft C command line definition
  23. #undef MT905
  24. #define MT905 1
  25. */
  26.  
  27. #define VERSION_NO    "2.10"        /* DVI driver version number */
  28.  
  29. #ifdef MT905
  30. #define  DEVICE_ID    "Mannesmann Tally MT905 Laser Printer"
  31.                 /* this string is printed at runtime */
  32. #define OUTFILE_EXT    "mtp"
  33. #else
  34. #define  DEVICE_ID    "Hewlett-Packard LaserJet Plus laser printer"
  35.                 /* this string is printed at runtime */
  36. #define OUTFILE_EXT    "jep"
  37. #endif
  38.  
  39. #define  BYTE_SIZE      8        /* output file byte size */
  40.  
  41. #undef STDRES
  42. #define STDRES  1            /* to get standard font resolution */
  43.  
  44. #define  MAXLINE    4096        /* maximum input file line size */
  45.                     /* it is needed only in special() */
  46.  
  47. #define  MAXPAGEFONTS    16        /* silly limit on fonts/page */
  48.  
  49. #define  XDPI        300        /* horizontal dots/inch */
  50. #define  XPSIZE        8        /* horizontal paper size in inches */
  51. #define  XSIZE        (((XDPI*XPSIZE+2*HOST_WORD_SIZE-1)/\
  52.                 (2*HOST_WORD_SIZE))*(2*HOST_WORD_SIZE))
  53.                     /* number of horizontal dots; */
  54.                     /* MUST BE multiple of */
  55.                     /* 2*HOST_WORD_SIZE */
  56.  
  57. #define  YDPI        300        /* vertical dots/inch */
  58. #define  YPSIZE        11        /* vertical paper size in inches */
  59. #define  YSIZE        (YDPI*YPSIZE)    /* number of vertical dots */
  60.  
  61. #define XORIGIN        30        /* measured pixel coordinates of */
  62. #define YORIGIN        -15        /* page origin (should be at (0,0) */
  63.  
  64. /***********************************************************************
  65. Define some  useful  shorthand macros  for  all required  LaserJet  Plus
  66. commands.  With the exception of the CREATEFONT and DOWNLOADCHAR macros,
  67. which require extra data,  NO escape sequences  appear anywhere else  in
  68. the text.
  69.  
  70. The LaserJet Plus allows coordinates in  dots as well as the  decipoints
  71. supported by the regular LaserJet.  Dot coordinates are more convenient,
  72. so we use them exclusively.  The Plus puts the page origin in the upper-
  73. left corner, while we have it in the lower-left corner, so MOVEY adjusts
  74. the coordinate accordingly.
  75.  
  76. With 7-bit fonts, only characters 33..127 are printable, and with  8-bit
  77. fonts, 33..127 and 160..255 are printable.  Since TeX assumes characters
  78. 0..127 are available, we  remap character numbers  in 0..32 to  160..192
  79. and use 8-bit fonts.  The macros conceal the remapping.
  80.  
  81. Whenever possible,  escape  sequences  are  combined  and  0  parameters
  82. omitted, in order to compress the output.
  83. ***********************************************************************/
  84.  
  85. /* Begin raster graphics .. {transfer raster graphics} .. end raster graphics */
  86. #define BEGIN_RASTER_GRAPHICS    OUTS("\033*t300R\033*r1A")
  87.  
  88. /* CREATE_FONT must be followed by a 26-byte font header (see readfont) */
  89. #define CREATE_FONT OUTS("\033\051s26W")
  90.  
  91. #define DELETE_ALL_FONTS OUTS("\033*cF")
  92.  
  93. /* DOWNLOAD_CHARACTER is not a complete specification---it must be followed by
  94. two-byte values of xoff, yoff, width, height, deltax */
  95. #define DOWNLOAD_CHARACTER(nbytes) OUTF("\033\050s%dW",(nbytes)+16)
  96.  
  97. /* End raster graphics */
  98. #define END_RASTER_GRAPHICS    OUTS("\033*rB")
  99.  
  100. /* Map characters (0..32,33..127) to (160..192,33..127) */
  101. #define MAP_CHAR(c) (((c) > 32) ? (c) : ((c) + 160))
  102.  
  103. /* Move absolute to (x,y), page origin in lower left corner */
  104. #define MOVETO(x,y) OUTF2("\033*p%dx%dY",(x),YSIZE-(y))
  105.  
  106. /* Move absolute to (x,current y), page origin in lower left corner */
  107. #define MOVEX(x) OUTF("\033*p%dX",(x))
  108.  
  109. /* Move absolute to (current x,y), page origin in lower left corner */
  110. #define MOVEY(y) OUTF("\033*p%dY",YSIZE-(y))
  111.  
  112. /* Output TeX character number with mapping to HP LaserJet Plus number */
  113. #define OUT_CHAR(c) OUTC(MAP_CHAR(c))
  114.  
  115. /* Output a 16-bit binary number in two bytes */
  116. #define OUT16(n) {OUTC((n)>>8); OUTC((n));}
  117.  
  118. /* Eject a page from the printer--this is the last command on each page */
  119. #define PAGEEJECT OUTC('\f')
  120.  
  121. /* Reset printer  at job  start.  <ESC>E  is global  reset which  clears
  122. everything but permanent fonts, which  we do not use.  <ESC>&l0E  resets
  123. left margin to  0.  <ESC>&a0L resets  top margin to  0.  Without  these,
  124. default margins  are supplied  which  lie inside  page.   Unfortunately,
  125. these do not permit negative values,  so we have to further correct  the
  126. origin with  (XORIGIN,  YORIGIN)  defined above;  these  bias  (lmargin,
  127. tmargin) set in dviinit(). */
  128. #define RESET_PRINTER OUTS("\033E\033&lE\033&aL")
  129.  
  130. /* Move relative by (delx,dely) from current point */
  131. #define RMOVETO(delx,dely) {\
  132. if ((delx) == 0)\
  133.     RMOVEY(dely)\
  134. else if ((dely) == 0)\
  135.     RMOVEX(delx)\
  136. else\
  137.     OUTF2("\033*p%c%dx%c%dY",\
  138.         ((delx) > 0 ? '+' : '-'),ABS(delx),\
  139.         ((dely) < 0 ? '+' : '-'),ABS(dely));\
  140. }
  141.  
  142. /* Move relative to (delx+currentx,currenty), page origin in lower  left
  143. corner */
  144. #define RMOVEX(delx) {\
  145. if ((delx) > 0)\
  146.     OUTF("\033*p+%dX",(delx));\
  147. else if ((delx) < 0)\
  148.     OUTF("\033*p%dX",(delx));\
  149. }
  150.  
  151. /* Move relative to (currentx,dely+currenty), page origin in lower  left
  152. corner */
  153. #define RMOVEY(dely) {\
  154. if ((dely) > 0)\
  155.     OUTF("\033*p%dY",-(dely));\
  156. else if ((dely) < 0)\
  157.     OUTF("\033*p+%dY",-(dely));\
  158. }
  159.  
  160. /* Round a POSITIVE floating-point value to the nearest integer */
  161. #define ROUND(x) ((int)(x + 0.5))
  162.  
  163. /* Output a new rule at TeX position (x,y).  The device coordinates will
  164. be changed on completion.  The rule origin is the TeX convention of  the
  165. lower-left corner, while the LaserJet  Plus uses the upper-left  corner.
  166. */
  167. #define RULE(x,y,width,height) {\
  168.     MOVETO(x,(y)+height-1);\
  169.     OUTF2("\033*c%da%dbP",width,height);\
  170. }
  171.  
  172. /* Set rule of  same size as  previous one at  TeX position (x,y).   The
  173. device coordinates will be changed on completion. */
  174. #define RULE2(x,y) {\
  175.     MOVETO(x,(y)+rule_height-1);\
  176.     OUTS("\033*cP");\
  177. }
  178.  
  179. /* Set the current font and character in preparation for a DOWNLOAD_CHARACTER */
  180. #define SET_CHAR_CODE(fontnumber,ch) {\
  181. if (fontnumber)\
  182.     OUTF2("\033*c%dd%dE",fontnumber,MAP_CHAR(ch));\
  183. else\
  184.     OUTF("\033*cd%dE",MAP_CHAR(ch));\
  185. }
  186.  
  187. /* Set the number of copies of the current page (issue just before
  188. PAGEEJECT) */
  189. #define SETCOPIES(n) OUTF("\033&l%dX",MAX(1,MIN(n,99)))
  190.  
  191. /* Set the font number in preparation for a CREATE_FONT */
  192. #define SET_FONT_ID(fontnumber) OUTF("\033*c%dd4F",(fontnumber));
  193.  
  194. #define TRANSFER_RASTER_GRAPHICS(nbytes) OUTF("\033*b%dW",(nbytes));
  195.  
  196. #define UNDEFINED_FONT 65535        /* fonts are numbered 0,1,2,... */
  197.  
  198. /* In order to handle the MAXPAGEFONTS restriction, we keep a set of the
  199. fonts in  use, accessing  them with  these two  functions.  If  a  later
  200. printer model increases MAXFONTS beyond 32, we can transparently  change
  201. to another  representation,  but  for  now,  we  use  an  efficient  bit
  202. set implementation. */
  203.  
  204. UNSIGN32 page_members;            /* the bit set for current page */
  205. #define ADD_MEMBER(set,member) {set |= (1 << (member));}
  206. #define IS_MEMBER(set,member) (set & (1 << (member)))
  207. #define EMPTY_SET(set) {set = 0L;}
  208.  
  209. #include "main.h"
  210. #include "abortrun.h"
  211. #include "actfact.h"
  212. #include "alldone.h"
  213.  
  214. /*-->bopact*/
  215. /**********************************************************************/
  216. /******************************* bopact *******************************/
  217. /**********************************************************************/
  218.  
  219. void
  220. bopact()            /* beginning of page action */
  221. {
  222.     page_fonts = 0;        /* no fonts used on this page yet */
  223.     EMPTY_SET(page_members);
  224.  
  225.     rule_height = -1;        /* reset last rule parameters */
  226.     rule_width = -1;
  227.  
  228.     str_ycp = -1;        /* reset string y coordinate */
  229. }
  230.  
  231. #include "chargf.h"
  232. #include "charpk.h"
  233. #include "charpxl.h"
  234. #include "clrrow.h"
  235. #include "dbgopen.h"
  236.  
  237. /*-->devinit*/
  238. /**********************************************************************/
  239. /****************************** devinit *******************************/
  240. /**********************************************************************/
  241.  
  242. void
  243. devinit(argc,argv)        /* initialize device */
  244. int argc;
  245. char *argv[];
  246. {
  247.     RESET_PRINTER;        /* printer reset */
  248.     DELETE_ALL_FONTS;        /* delete all downloaded fonts */
  249.     font_count = 0;        /* no font numbers are assigned yet */
  250.     font_switched = TRUE;
  251. }
  252.  
  253. /*-->devterm*/
  254. /**********************************************************************/
  255. /****************************** devterm *******************************/
  256. /**********************************************************************/
  257.  
  258. void
  259. devterm()            /* terminate device */
  260. {
  261.     DELETE_ALL_FONTS;        /* delete all downloaded fonts */
  262.     RESET_PRINTER;        /* printer reset */
  263. }
  264.  
  265. #include "dvifile.h"
  266. #include "dviinit.h"
  267. #include "dviterm.h"
  268.  
  269. /*-->eopact*/
  270. /**********************************************************************/
  271. /******************************* eopact *******************************/
  272. /**********************************************************************/
  273.  
  274. void
  275. eopact()            /* end of page action */
  276. {
  277.     if (copies > 1)
  278.         SETCOPIES(copies);
  279.     PAGEEJECT;
  280. }
  281.  
  282. #include "f20open.h"
  283. #include "fatal.h"
  284.  
  285. /*-->fillrect*/
  286. /**********************************************************************/
  287. /****************************** fillrect ******************************/
  288. /**********************************************************************/
  289.  
  290. void
  291. fillrect(x,y,width,height)
  292. COORDINATE x,y,width,height;        /* lower left corner, size */
  293.  
  294. /***********************************************************************
  295. With the  page origin  (0,0) at  the lower-left  corner, draw  a  filled
  296. rectangle at (x,y).
  297.  
  298. For most  TeX  uses, rules  are  uncommon, and  little  optimization  is
  299. possible.  However, for the LaTeX Bezier option, curves are simulated by
  300. many small rules (typically  2 x 2)  separated by positioning  commands.
  301. By remembering  the size  of the  last rule  set, we  can test  for  the
  302. occurrence of repeated rules of the same size, and reduce the output  by
  303. omitting the rule  sizes.  The  last rule  parameters are  reset by  the
  304. begin-page action in prtpage(), so they do not carry across pages.
  305.  
  306. It is not possible to use relative, instead of absolute, moves in  these
  307. sequences, without stacking rules for the whole page, because each  rule
  308. is separated in  the DVI file  by push, pop,  and positioning  commands,
  309. making  for  an  uncertain  correspondence  between  internal  (xcp,ycp)
  310. pixel page coordinates and external device coordinates.
  311.  
  312. The last string y coordinate, str_ycp,  must be reset here to force  any
  313. later setstring() to reissue new absolute positioning commands.
  314. ***********************************************************************/
  315.  
  316. {
  317.      str_ycp = -1;        /* invalidate string y coordinate */
  318.  
  319.     if ((height != rule_height) || (width != rule_width))
  320.     {
  321.     RULE(x,y,width,height);
  322.     rule_width = width;    /* save current rule parameters */
  323.     rule_height = height;
  324.     }
  325.     else            /* same size rule again */
  326.     RULE2(x,y);
  327. }
  328.  
  329. #include "findpost.h"
  330. #include "fixpos.h"
  331. #include "fontfile.h"
  332. #include "fontsub.h"
  333. #include "getbytes.h"
  334. #include "getfntdf.h"
  335. #include "getpgtab.h"
  336. #include "inch.h"
  337. #include "initglob.h"
  338.  
  339. /*-->loadbmap*/
  340. /**********************************************************************/
  341. /****************************** loadbmap ******************************/
  342. /**********************************************************************/
  343.  
  344. void
  345. loadbmap(c)            /* load big character as raster bitmap */
  346. register BYTE c;
  347. {
  348.     register struct char_entry *tcharptr;  /* temporary char_entry pointer */
  349.     void (*charyy)();        /* subterfuge to get around PCC-20 bug */
  350.  
  351.     if (fontptr != pfontptr)
  352.     (void)openfont(fontptr->n);
  353.     if (fontfp == (FILE *)NULL)    /* do nothing if no font file */
  354.     return;
  355.  
  356.     tcharptr = &(fontptr->ch[c]);
  357.  
  358.     moveto(hh - tcharptr->xoffp,YSIZE-vv+tcharptr->yoffp);
  359.  
  360.     MOVETO(xcp,ycp);
  361.     BEGIN_RASTER_GRAPHICS;
  362.  
  363.     /* Bug fix: PCC-20 otherwise jumps to charxx instead of *charxx */
  364.     charyy = fontptr->charxx;
  365.     (void)(*charyy)(c,outraster);    /* load rasters into device */
  366.  
  367.     END_RASTER_GRAPHICS;
  368.     str_ycp = -1;        /* invalidate string y coordinate */
  369. }
  370.  
  371. /*-->loadchar*/
  372. /**********************************************************************/
  373. /****************************** loadchar ******************************/
  374. /**********************************************************************/
  375.  
  376. void
  377. loadchar(c)
  378. register BYTE c;
  379. {
  380.     void (*charyy)();        /* subterfuge to get around PCC-20 bug */
  381.     register struct char_entry *tcharptr; /* temporary char_entry pointer */
  382.     COORDINATE nbytes;            /* number of bytes per row */
  383.     float temp;
  384.     INT16 ntemp;
  385.  
  386.     if ((c < FIRSTPXLCHAR) || (LASTPXLCHAR < c)) /* check character range */
  387.     return;
  388.  
  389.     tcharptr = &(fontptr->ch[c]);
  390.  
  391.     if (!VISIBLE(tcharptr))
  392.     return;                /* do nothing for invisible fonts */
  393.  
  394.     if (fontptr != pfontptr)
  395.     openfont(fontptr->n);
  396.  
  397.     if (fontfp == (FILE *)NULL)        /* do nothing if no font file */
  398.     return;
  399.  
  400.     (void)clearerr(plotfp);
  401.  
  402.     tcharptr->isloaded = TRUE;
  403.  
  404.     SET_CHAR_CODE(fontptr->font_number,c);
  405.  
  406.     /* Number of bytes in bitmap, possibly reduced because of LaserJet Plus */
  407.     /* limits.  Large characters really need to be handled as bitmaps */
  408.     /* instead of as downloaded characters. */
  409.  
  410.     nbytes = ((tcharptr->wp) + 7) >> 3;        /* wp div 8 */
  411.     DOWNLOAD_CHARACTER(MIN(16,nbytes)*MIN(255,(tcharptr->hp)));
  412.  
  413.     OUTC(4);            /* 4 0 14 1 is fixed sequence */
  414.     OUTC(0);
  415.  
  416.     OUTC(14);
  417.     OUTC(1);
  418.  
  419.     OUTC(0);            /* orientation = 0 ==> portrait */
  420.     OUTC(0);
  421.  
  422.     /* Apologies for the temporary variables; the Sun OS 3.2 cc could
  423.     not compile the original expressions. */
  424.     ntemp = MIN(-(tcharptr->xoffp),127);
  425.     ntemp = MAX(-128,ntemp);
  426.     OUT16(ntemp);
  427.     ntemp = MIN(tcharptr->yoffp,127);
  428.     ntemp = MAX(-128,ntemp);
  429.     OUT16(ntemp);
  430.     ntemp = MIN(128,tcharptr->wp);
  431.     OUT16(ntemp);
  432.     ntemp = MIN(255,tcharptr->hp);
  433.     OUT16(ntemp);
  434.     temp = (float)(tcharptr->tfmw);
  435.     temp = 4.0*temp*conv;
  436.     ntemp = ROUND(temp);
  437. #ifdef MT905
  438.     ntemp = ((ntemp+2)/4)*4;            /* MTP fix for nearest dot    */
  439. #endif
  440.     OUT16(ntemp);            /* delta x to nearest 1/4 dot */
  441.  
  442.     /* Bug fix: PCC-20 otherwise jumps to charxx instead of *charxx */
  443.     charyy = fontptr->charxx;
  444.     (void)(*charyy)(c,outrow);        /* output rasters */
  445.  
  446.     if (DISKFULL(plotfp))
  447.     (void)fatal("loadchar():  Output error -- disk storage probably full");
  448. }
  449.  
  450. /*-->makefont*/
  451. /**********************************************************************/
  452. /***************************** makefont *******************************/
  453. /**********************************************************************/
  454.  
  455. void
  456. makefont()
  457. {
  458.     register UNSIGN16 the_char;    /* loop index */
  459.     INT16 j;            /* loop index */
  460.                 /* parameters of largest cell */
  461.     COORDINATE cell_above;    /* dots above baseline */
  462.     COORDINATE cell_below;    /* dots below baseline */
  463.     COORDINATE char_below;    /* dots below baseline */
  464.     COORDINATE cell_height;    /* total height */
  465.     COORDINATE cell_left;    /* dots left of character cell */
  466.     COORDINATE cell_width;    /* total width */
  467.     COORDINATE cell_baseline;    /* in 0..(cell_height-1) */
  468.  
  469.     /*******************************************************************
  470.     Each LaserJet  Plus  font  must  be  assigned  a  unique  number  in
  471.     0..32767, and only 32 fonts  can be active at  one time.  We keep  a
  472.     table of font pointers for this purpose and store the  corresponding
  473.     table index in font_number.  Each time a new font is encountered, we
  474.     increment font_count and  store it in  that font's font_number.  TeX
  475.     produces a unique font number as well, and TeX82 only uses values in
  476.     the range 0..255.  The DVI file supports 32-bit font numbers, so  it
  477.     is better to generate  our own, because  someday other programs  may
  478.     produce DVI files too.
  479.  
  480.     If fonts are freed dynamically, the table entry must be  invalidated
  481.     and a command sent to the printer to delete that font.  At  present,
  482.     font freeing happens only in dviterm() at the close of processing of
  483.     a single DVI file.  A subsequent  DVI file processed will result  in
  484.     the invocation of devinit() which resets font_count to 0.  It is not
  485.     possible to  avoid  downloading  some fonts  for  subsequent  files,
  486.     because we have no control over what order they are printed in,  and
  487.     each output file must therefore be regarded as independent.
  488.  
  489.     In order to  deal with  the limit of  MAXFONTS active  fonts in  the
  490.     LaserJet Plus, we  have two choices.   The first and  best and  most
  491.     difficult, is to  entirely discard  the matching of  TeX fonts  with
  492.     LaserJet Plus fonts---new characters would simply be assigned to the
  493.     next available entry in the current open font.  The second choice is
  494.     less satisfactory---when  MAXFONTS fonts  have been  downloaded,  we
  495.     delete the last  of them and  reset the isloaded  flags for all  the
  496.     characters  in  that  font.   The  Plus  also  allows  deletion   of
  497.     individual characters,  so  in  the  first  case,  we  could  delete
  498.     little-used characters  to  make room  in  the font  tables  on  the
  499.     device; we do not use that approach here.  One problem is that  font
  500.     metrics must be assigned  which match the  largest character in  the
  501.     font, so  individual  character deletion  and  later re-use  of  the
  502.     vacated slot is not  in general possible.  A  second problem is  the
  503.     bizarre behavior  of  the  LaserJet  Plus  in  response  to  a  font
  504.     deletion--the current page  is printed, and  the all text  following
  505.     the delete font command will appear on the next page.
  506.  
  507.     There is a  silly restriction  that only MAXPAGEFONTS  fonts can  be
  508.     used on a  single page,  where MAXPAGEFONTS <  MAXFONTS.  We  handle
  509.     this by keeping a count, page_fonts,  of the number of fonts in  use
  510.     on the  current  page,  and  whenever  a  font  is  requested  whose
  511.     font_number  (0,1,...)   reaches   or  exceeds  MAXPAGEFONTS,   then
  512.     setchar() and setstr()  will not  download the character  as a  font
  513.     character, but instead will set it  as a raster bitmap, in the  same
  514.     fashion that large characters are handled.
  515.  
  516.     We handle the font deletion misfeature  by just not using it.  If  a
  517.     document requires more than MAXFONTS fonts, then the characters  for
  518.     those additional  fonts  are  sent as  raster  bitmaps,  instead  of
  519.     downloaded characters.
  520.  
  521.     These two actions completely  remove any limitation  on the size  or
  522.     number of fonts in the LaserJet Plus.
  523.  
  524.     As an optimization  to reduce  the effort of  font table  searching,
  525.     each time a font is requested which has already been loaded, we move
  526.     that font to the front of font_table[]; the least popular fonts will
  527.     therefore be the  ones that  get deleted.  The  least recently  used
  528.     priority mechanism is  widely used in  operating systems for  buffer
  529.     management; the overhead of  list rearrangement here is  acceptable,
  530.     because font changing  occurs relatively  infrequently, compared  to
  531.     character setting.
  532.  
  533.     <------wp------>
  534.     ^    ................
  535.     |    ................
  536.     |    ................
  537.     |    ................
  538.     |    ................
  539.     |    ................
  540.     |    ................
  541.     hp  ................
  542.     |    ................
  543.     |    ................
  544.     |    ................
  545.     |    .....o..........       <-- character reference point (xcp,ycp) at "o"
  546.     |    ................ ^
  547.     |    ................ |
  548.     |    ................ |--- (hp - yoffp - 1)
  549.     |    ................ |
  550.     v    +............... v     <-- (xcorner,ycorner) at "+"
  551.     <--->
  552.       |
  553.       |
  554.      xoffp (negative if (xcp,ycp) left of bitmap)
  555.  
  556.  
  557.     The LaserJet Plus  font mechanism requires  the declaration of  cell
  558.     height, width, and baseline in the CreateFont command.   Experiments
  559.     show that  these must  be large  enough to  incorporate the  maximum
  560.     extent above and below the baseline  of any characters in the  font.
  561.     The metric correspondences are as follows:
  562.  
  563.     -----            -------------
  564.     TeX                LaserJet Plus
  565.     -----            -------------
  566.     xoffp            -(left offset)
  567.     yoffp            top offset
  568.     max(yoffp) + 1        cell baseline
  569.     max(wp)            cell width
  570.     max(yoffp) +
  571.     max(hp-yoff,yoff-hp) + 1    cell height
  572.  
  573.     *******************************************************************/
  574.  
  575.     if (font_count >= MAXFONTS)    /* then no more fonts can be downloaded */
  576.     {
  577.     /* set up so BIGCHAR() recognizes the font as not downloadable
  578.     and sends bitmaps instead */
  579.     fontptr->font_number = font_count;
  580.     for (the_char = FIRSTPXLCHAR; the_char <= LASTPXLCHAR; ++the_char)
  581.     {
  582.         fontptr->ch[the_char].isloaded = FALSE;
  583.         fontptr->ch[the_char].istoobig = TRUE;
  584.     }
  585.     return;
  586.     }
  587.     for (j = 0; j < (INT16)font_count; ++j)
  588.     if (font_table[j] == fontptr)    /* then font already known */
  589.     {
  590.         for (; j > 0; --j)        /* LRU: move find to front */
  591.             font_table[j] = font_table[j-1];
  592.         font_table[0] = fontptr;
  593.         return;            /* nothing more to do */
  594.     }
  595.  
  596.     if (j >= (INT16)font_count)        /* new font */
  597.     {
  598.     fontptr->font_number = font_count;
  599.     font_table[font_count] = fontptr;
  600.     font_count++;            /* count the next font */
  601.  
  602.     cell_above = 0;
  603.     cell_below = 0;
  604.     cell_left = 0;
  605.     cell_width = 0;
  606.  
  607.     for (the_char = FIRSTPXLCHAR; the_char <= LASTPXLCHAR; ++the_char)
  608.     {
  609.         char_below = fontptr->ch[the_char].yoffp -
  610.             fontptr->ch[the_char].hp;
  611.         char_below = ABS(char_below);
  612.         cell_height = 1 + fontptr->ch[the_char].yoffp + char_below;
  613.         fontptr->ch[the_char].isloaded = FALSE;
  614.         fontptr->ch[the_char].istoobig = (BOOLEAN)(
  615.             !IN(-128,-fontptr->ch[the_char].xoffp,127) ||
  616.         !IN(-128, fontptr->ch[the_char].yoffp,127) ||
  617.         !IN(1,fontptr->ch[the_char].wp,255) ||
  618.         !IN(1,cell_height,255));
  619.         cell_above = MAX(cell_above,fontptr->ch[the_char].yoffp);
  620.         cell_below = MAX(cell_below,char_below);
  621.         cell_left = MAX(cell_left,-fontptr->ch[the_char].xoffp);
  622.         cell_width = MAX(cell_width,fontptr->ch[the_char].wp);
  623.     }
  624.     cell_baseline = cell_above + 1;
  625.     cell_height = cell_above + cell_below + 1;
  626.  
  627.     if ((cell_width > 255) || (cell_height > 255))
  628.     {    /* don't worry, big characters are handled specially later */
  629.         cell_height = MIN(cell_height,255);
  630.         cell_width = MIN(cell_width,255);
  631.     }
  632.     cell_width = MAX(1,cell_width);
  633.  
  634.     SET_FONT_ID(fontptr->font_number);
  635.  
  636.     CREATE_FONT;
  637.  
  638.     OUTC(0);
  639.     OUTC(26);        /* descriptor length */
  640.  
  641.     OUTC(0);        /* always 0 */
  642.     OUTC(1);        /* 8-bit font (for more than 95 characters) */
  643.  
  644.     OUT16(0);        /* always 0 */
  645.  
  646.     OUT16(cell_baseline);    /* baseline position (in 0..cell_height-1)*/
  647.  
  648.     OUT16(cell_width);    /* cell width */
  649.  
  650.     OUT16(cell_height);    /* cell height */
  651.  
  652.     OUTC(0);        /* orientation = 0 ==> portrait */
  653.     OUTC(1);        /* spacing = 1 ==> proportional */
  654.  
  655.     OUT16(0);        /* symbol set (arbitrary) */
  656.  
  657.     OUT16(2);        /* pitch (arbitrary in 2..1260) */
  658.  
  659.     OUT16(cell_height);    /* font height (arbitrary in 0..10922) */
  660.  
  661.     OUT16(0);        /* always 0 */
  662.  
  663.     OUTC(0);        /* always 0 */
  664.     OUTC(0);        /* style = 0 ==> upright */
  665.  
  666.     OUTC(0);        /* stroke weight = 0 ==> normal */
  667.     OUTC(0);        /* typeface = 0 (arbitrary) */
  668.     }
  669. }
  670.  
  671. #include "movedown.h"
  672. #include "moveover.h"
  673. #include "moveto.h"
  674.  
  675. /*-->newfont*/
  676. /**********************************************************************/
  677. /****************************** newfont *******************************/
  678. /**********************************************************************/
  679.  
  680. void
  681. newfont()
  682. {
  683.     /*******************************************************************
  684.     Creating fonts immediately  (usually at postamble  read time, before
  685.     any pages have been  printed), would exhaust  the LaserJet Plus font
  686.     supply in a  document with more than  32 fonts, requiring many fonts
  687.     to be sent as bitmaps, instead of as downloaded characters.  If only
  688.     a few pages were  selected for  printing,  it  is unlikely that more
  689.     than 32 would   actually  be needed.   With  character bitmaps,  the
  690.     output file is much larger than when downloaded characters are used,
  691.     and there is a likelihood of raising printer error code 21 (page too
  692.     complex to process), at least on the LaserJet Plus, which has rather
  693.     limited internal memory (about 512Kb).  The HPLJ  Series II can have
  694.     up to  4.5Mb  of memory, and possibly   would   eliminate this error
  695.     condition.
  696.  
  697.     Instead, we simply mark the font as currently undefined.  When it is
  698.     first referenced, setfont() will call  makefont() to actually create
  699.     it in the printer.
  700.     *******************************************************************/
  701.  
  702.     fontptr->font_number = UNDEFINED_FONT;
  703. }
  704.  
  705. #include "nosignex.h"
  706. #include "openfont.h"
  707. #include "option.h"
  708.  
  709. /*-->outraster*/
  710. /**********************************************************************/
  711. /***************************** outraster ******************************/
  712. /**********************************************************************/
  713.  
  714. void
  715. outraster(c,yoff)/* print single raster line in bitmap graphics mode */
  716. BYTE c;        /* current character value */
  717. UNSIGN16 yoff;    /* offset from top row (0,1,...,hp-1)  */
  718. {
  719.     UNSIGN16 bytes_per_row;    /* number of raster bytes to copy */
  720.     register UNSIGN16 k;    /* loop index */
  721.     register UNSIGN32 *p;    /* pointer into img_row[] */
  722.     struct char_entry *tcharptr;/* temporary char_entry pointer */
  723.     register BYTE the_byte;    /* unpacked raster byte */
  724.  
  725.     tcharptr = &(fontptr->ch[c]);/* assume check for valid c has been done */
  726.     bytes_per_row = (UNSIGN16)((tcharptr->wp) + 7) >> 3; /* wp div 8 */
  727.     p = img_row;        /* we step pointer p along img_row[] */
  728.  
  729.     TRANSFER_RASTER_GRAPHICS(bytes_per_row);
  730.  
  731.     for (k = bytes_per_row; k > 0; ++p)
  732.     {
  733.     the_byte = (BYTE)((*p) >> 24);
  734.     OUTC(the_byte);
  735.     if ((--k) <= 0)
  736.         break;
  737.  
  738.     the_byte = (BYTE)((*p) >> 16);
  739.     OUTC(the_byte);
  740.     if ((--k) <= 0)
  741.         break;
  742.  
  743.     the_byte = (BYTE)((*p) >> 8);
  744.     OUTC(the_byte);
  745.     if ((--k) <= 0)
  746.         break;
  747.  
  748.     the_byte = (BYTE)(*p);
  749.     OUTC(the_byte);
  750.     if ((--k) <= 0)
  751.         break;
  752.     }
  753. }
  754.  
  755. /*-->outrow*/
  756. /**********************************************************************/
  757. /******************************* outrow *******************************/
  758. /**********************************************************************/
  759.  
  760. void
  761. outrow(c,yoff)    /* copy img_row[] into rasters[] if allocated, else no-op */
  762. BYTE c;        /* current character value */
  763. UNSIGN16 yoff;    /* offset from top row (0,1,...,hp-1)  */
  764. {
  765.     UNSIGN16 bytes_per_row;    /* number of raster bytes to copy */
  766.     register UNSIGN16 k;    /* loop index */
  767.     register UNSIGN32 *p;    /* pointer into img_row[] */
  768.     struct char_entry *tcharptr;/* temporary char_entry pointer */
  769.     register BYTE the_byte;    /* unpacked raster byte */
  770.  
  771.     if (yoff > 255)    /* LaserJet Plus cannot handle big characters */
  772.     return;
  773.  
  774.     tcharptr = &(fontptr->ch[c]);/* assume check for valid c has been done */
  775.     bytes_per_row = (UNSIGN16)((tcharptr->wp) + 7) >> 3; /* wp div 8 */
  776.     bytes_per_row = MIN(16,bytes_per_row);    /* limited to 128 bits/row */
  777.     p = img_row;        /* we step pointer p along img_row[] */
  778.  
  779.     for (k = bytes_per_row; k > 0; ++p)
  780.     {
  781.     the_byte = (BYTE)((*p) >> 24);
  782.     OUTC(the_byte);
  783.     if ((--k) <= 0)
  784.         break;
  785.  
  786.     the_byte = (BYTE)((*p) >> 16);
  787.     OUTC(the_byte);
  788.     if ((--k) <= 0)
  789.         break;
  790.  
  791.     the_byte = (BYTE)((*p) >> 8);
  792.     OUTC(the_byte);
  793.     if ((--k) <= 0)
  794.         break;
  795.  
  796.     the_byte = (BYTE)(*p);
  797.     OUTC(the_byte);
  798.     if ((--k) <= 0)
  799.         break;
  800.     }
  801. }
  802.  
  803. #include "prtpage.h"
  804. #include "readfont.h"
  805. #include "readgf.h"
  806. #include "readpk.h"
  807. #include "readpost.h"
  808. #include "readpxl.h"
  809. #include "reldfont.h"
  810. #include "rulepxl.h"
  811.  
  812. /*-->setchar*/
  813. /**********************************************************************/
  814. /****************************** setchar *******************************/
  815. /**********************************************************************/
  816.  
  817. void
  818. setchar(c, update_h)
  819. register BYTE c;
  820. register BOOLEAN update_h;
  821. {
  822.     register struct char_entry *tcharptr;  /* temporary char_entry pointer */
  823.  
  824.     /* BIGCHAR() and ONPAGE() are used here and in setstr().  BIGCHAR()
  825.     is TRUE if the character is too big to send as a downloaded font, or
  826.     if more than MAXPAGEFONTS have been used on this page, and the
  827.     required font's font_number is not in the page_members set, or if
  828.     more the font is not in the first MAXFONTS fonts. */
  829.  
  830. #define BIGCHAR(t) (((t->wp > (COORDINATE)size_limit) ||\
  831. (t->hp > (COORDINATE)size_limit)) || (fontptr->font_number >= MAXFONTS) ||\
  832. (t->istoobig) ||\
  833. ((page_fonts > MAXPAGEFONTS) && !IS_MEMBER(page_members,fontptr->font_number)))
  834.  
  835. #define ONPAGE(t) (((hh - t->xoffp + t->pxlw) <= XSIZE) \
  836.     && (hh >= 0)\
  837.     && (vv <= YSIZE)\
  838.     && (vv >= 0))
  839.  
  840.     if (DBGOPT(DBG_SET_TEXT))
  841.     {
  842.     (void)fprintf(stderr,"setchar('");
  843.     if (isprint(c))
  844.         (void)putc(c,stderr);
  845.     else
  846.         (void)fprintf(stderr,"\\%03o",(int)c);
  847.     (void)fprintf(stderr,"'<%d>) (hh,vv) = (%ld,%ld) font name <%s>",
  848.         (int)c, (long)hh, (long)vv, fontptr->n);
  849.     NEWLINE(stderr);
  850.     }
  851.  
  852.     tcharptr = &(fontptr->ch[c]);
  853.  
  854.     moveto(hh,(COORDINATE)(YSIZE-vv));
  855.     if (ONPAGE(tcharptr))
  856.     {                /* character fits entirely on page */
  857.     if (font_switched)
  858.     {
  859.         (void)setfont();
  860.         font_switched = FALSE;
  861.     }
  862.  
  863.     if (VISIBLE(tcharptr))
  864.     {
  865.         if (BIGCHAR(tcharptr))
  866.         loadbmap(c);
  867.         else
  868.         {
  869.         if (!tcharptr->isloaded)
  870.              loadchar(c);
  871.  
  872.         if (ycp != str_ycp)
  873.         {
  874.             MOVETO(xcp,ycp);
  875.             str_ycp = ycp;
  876.         }
  877.         else
  878.                 MOVEX(xcp);
  879.  
  880.         OUT_CHAR(c);
  881.         }
  882.     }
  883.     }
  884.     else if (DBGOPT(DBG_OFF_PAGE) && !quiet)
  885.     {                /* character is off page -- discard it */
  886.     (void)fprintf(stderr,
  887.         "setchar(): Char %c [10#%3d 8#%03o 16#%02x] off page.",
  888.         isprint(c) ? c : '?',c,c,c);
  889.     NEWLINE(stderr);
  890.     }
  891.  
  892.     if (update_h)
  893.     {
  894.     h += (INT32)tcharptr->tfmw;
  895.     hh += (COORDINATE)tcharptr->pxlw;
  896.     hh = fixpos(hh-lmargin,h,conv) + lmargin;
  897.     }
  898. }
  899.  
  900. #include "setfntnm.h"
  901.  
  902. /*-->setfont*/
  903. /**********************************************************************/
  904. /****************************** setfont *******************************/
  905. /**********************************************************************/
  906.  
  907. void
  908. setfont()
  909. {
  910.     if (fontptr->font_number == UNDEFINED_FONT)
  911.     (void)makefont();
  912.     if (!IS_MEMBER(page_members,fontptr->font_number))
  913.     page_fonts++;
  914.     if (page_fonts <= MAXPAGEFONTS)
  915.     ADD_MEMBER(page_members,fontptr->font_number);
  916.     if (!((fontptr->font_number >= MAXFONTS) || ((page_fonts > MAXPAGEFONTS) &&
  917.        !IS_MEMBER(page_members,fontptr->font_number))))
  918.     {
  919.     if (fontptr->font_number)
  920.         OUTF("\033\050%dX",fontptr->font_number);
  921.     else
  922.         OUTS("\033\050X");
  923.     }
  924. }
  925.  
  926. #include "setrule.h"
  927.  
  928. /*-->setstr*/
  929. /**********************************************************************/
  930. /******************************* setstr *******************************/
  931. /**********************************************************************/
  932.  
  933. void
  934. setstr(c)
  935. register BYTE c;
  936. {
  937.     register struct char_entry *tcharptr;  /* temporary char_entry pointer */
  938.     register BOOLEAN inside;
  939.     INT32 h0,v0;        /* (h,v) at entry */
  940.     COORDINATE hh0,vv0;        /* (hh,vv) at entry */
  941.     COORDINATE hh_last;        /* hh before call to fixpos() */
  942.     register UNSIGN16 k;    /* loop index */
  943.     UNSIGN16 nstr;        /* number of characters in str[] */
  944.     BYTE str[MAXSTR+1];        /* string accumulator */
  945.     BOOLEAN truncated;        /* off-page string truncation flag */
  946.  
  947.     /*******************************************************************
  948.     Set a sequence of characters in SETC_000 .. SETC_127 with a  minimal
  949.     number of LaserJet Plus commands.  These sequences tend to occur  in
  950.     long clumps  in  a DVI  file,  and setting  them  together  whenever
  951.     possible substantially decreases  the overhead and  the size of  the
  952.     output file.  A sequence can be set as a single string if
  953.  
  954.     * TeX and LaserJet Plus coordinates of each character agree (may
  955.       not be true, since device coordinates are in multiples of  1/4
  956.       pixel; violation  of  this  requirement  can  be  detected  if
  957.       fixpos() changes hh, or if ycp != str_ycp), AND
  958.  
  959.     * each character is in the same font (this will always be true
  960.       in a sequence from a DVI file), AND
  961.  
  962.     * each character fits within the page boundaries, AND
  963.  
  964.     * each character definition is already loaded, AND
  965.  
  966.     * each character is from a visible font, AND
  967.  
  968.     * each  character bitmap  extent is smaller  than the size_limit
  969.       (which is  used to  enable discarding  large characters  after
  970.       each use in order  to conserve virtual  memory storage on  the
  971.       output device).
  972.  
  973.     Whenever any of these conditions  does not hold, any string  already
  974.     output is terminated, and a new one begun.
  975.  
  976.     Two output optimizations are implemented here.  First, up to  MAXSTR
  977.     (in practice more  than enough) characters  are collected in  str[],
  978.     and any  that  require downloading  are  handled.  Then  the  entire
  979.     string is set at once, subject to the above limitations.  Second, by
  980.     recording the vertical page coordinate, ycp, in the global  variable
  981.     str_ycp (reset  in  prtpage()  at begin-page  processing),  it  is
  982.     possible to avoid  outputting y coordinates  unnecessarily, since  a
  983.     single line of  text will  generally result  in many  calls to  this
  984.     function.
  985.     *******************************************************************/
  986.  
  987. #define BEGINSTRING {inside = TRUE;\
  988.     if (ycp != str_ycp)\
  989.     {\
  990.     MOVETO(xcp,ycp);\
  991.     str_ycp = ycp;\
  992.     }\
  993.     else\
  994.     MOVEX(xcp);}
  995.  
  996. #define ENDSTRING {inside = FALSE;}
  997.  
  998. #define OFF_PAGE (-1)    /* off-page coordinate value */
  999.  
  1000.     if (font_switched)    /* output new font selection */
  1001.     {
  1002.     (void)setfont();
  1003.     font_switched = FALSE;
  1004.     }
  1005.  
  1006.     inside = FALSE;
  1007.     truncated = FALSE;
  1008.  
  1009.     hh0 = hh;
  1010.     vv0 = vv;
  1011.     h0 = h;
  1012.     v0 = v;
  1013.     nstr = 0;
  1014.     while ((SETC_000 <= c) && (c <= SETC_127) && (nstr < MAXSTR))
  1015.     {            /* loop over character sequence */
  1016.     tcharptr = &(fontptr->ch[c]);
  1017.  
  1018.     moveto(hh,YSIZE-vv);
  1019.  
  1020.     if (ONPAGE(tcharptr) && VISIBLE(tcharptr))
  1021.     {        /* character fits entirely on page and is visible */
  1022.         if ((!tcharptr->isloaded) && (!BIGCHAR(tcharptr)))
  1023.             loadchar(c);
  1024.     }
  1025.     /* update horizontal positions in TFM and pixel units */
  1026.     h += (INT32)tcharptr->tfmw;
  1027.     hh += (COORDINATE)tcharptr->pxlw;
  1028.  
  1029.     str[nstr++] = c;        /* save string character */
  1030.  
  1031.     c = (BYTE)nosignex(dvifp,(BYTE)1);
  1032.     }
  1033.  
  1034.     /* put back character which terminated the loop */
  1035.     (void)UNGETC((int)(c),dvifp);
  1036.  
  1037.     hh = hh0;            /* restore coordinates at entry */
  1038.     vv = vv0;
  1039.     h = h0;
  1040.     v = v0;
  1041.  
  1042.     if (DBGOPT(DBG_SET_TEXT))
  1043.     {
  1044.     (void)fprintf(stderr,"setstr(\"");
  1045.     for (k = 0; k < nstr; ++k)
  1046.     {
  1047.         c = str[k];
  1048.         if (isprint(c))
  1049.             (void)putc(c,stderr);
  1050.         else
  1051.             (void)fprintf(stderr,"\\%03o",(int)c);
  1052.     }
  1053.     (void)fprintf(stderr,"\") (hh,vv) = (%ld,%ld) font name <%s>",
  1054.         (long)hh, (long)vv, fontptr->n);
  1055.     NEWLINE(stderr);
  1056.     }
  1057.  
  1058.     for (k = 0; k < nstr; ++k)
  1059.     {            /* loop over character sequence */
  1060.     c = str[k];
  1061.     tcharptr = &(fontptr->ch[c]);
  1062.     moveto(hh,YSIZE-vv);
  1063.  
  1064.     if (ONPAGE(tcharptr) && VISIBLE(tcharptr))
  1065.     {        /* character fits entirely on page and is visible */
  1066.         /* We must check first for a big character.  The character */
  1067.         /* may have been downloaded on a previous page, but if it is */
  1068.         /* not in the page_members font set, we must send it again */
  1069.         /* as a bitmap instead. */
  1070.         if (BIGCHAR(tcharptr))
  1071.         {
  1072.         if (inside)
  1073.             ENDSTRING;        /* finish any open string */
  1074.         loadbmap(c);
  1075.         }
  1076.         else            /* character already downloaded */
  1077.         {
  1078.         if (!inside)
  1079.             BEGINSTRING;
  1080.         OUT_CHAR(c);
  1081.         }
  1082.     }
  1083.     else        /* character does not fit on page -- output */
  1084.     {        /* current string and discard the character */
  1085.         truncated = TRUE;
  1086.         if (inside)
  1087.         ENDSTRING;
  1088.     }
  1089.     /* update horizontal positions in TFM and pixel units */
  1090.     h += (INT32)tcharptr->tfmw;
  1091.     hh += (COORDINATE)tcharptr->pxlw;
  1092.     hh_last = hh;
  1093.     hh = fixpos(hh-lmargin,h,conv) + lmargin;
  1094.     if (DBGOPT(DBG_POS_CHAR))
  1095.     {
  1096.         (void)fprintf(stderr,
  1097.         "[%03o] xcp = %d\tycp = %d\thh = %d\thh_last = %d\n",
  1098.         c,xcp,ycp,hh,hh_last);
  1099.     }
  1100.  
  1101.     /* If fixpos() changed position, we need new string next time */
  1102.     /* around.   Actually, since the LaserJet Plus stores character */
  1103.     /* widths in units of 1/4 dot, we could compute coordinates at */
  1104.     /* four times the precision, but for now, we start a new string */
  1105.     /* each time we have one or more dots of error. */
  1106.  
  1107.     if ((hh != hh_last) && inside)
  1108.         ENDSTRING;
  1109.     }
  1110.     if (truncated && DBGOPT(DBG_OFF_PAGE) && !quiet)
  1111.     {
  1112.     (void)fprintf(stderr,"setstr(): Text [");
  1113.     for (k = 0; k < nstr; ++k)
  1114.         (void)fprintf(stderr,isprint(str[k]) ? "%c" : "\\%03o",str[k]);
  1115.     (void)fprintf(stderr,"] truncated at page boundaries.");
  1116.     NEWLINE(stderr);
  1117.     }
  1118.     if (inside)        /* finish last string */
  1119.     ENDSTRING;
  1120. }
  1121.  
  1122. #include "signex.h"
  1123. #include "skgfspec.h"
  1124. #include "skipfont.h"
  1125. #include "skpkspec.h"
  1126. #include "special.h"
  1127. #include "strchr.h"
  1128. #include "strcm2.h"
  1129. #include "strid2.h"
  1130. #include "strrchr.h"
  1131. #include "tctos.h"
  1132. #include "usage.h"
  1133. #include "warning.h"
  1134.